/******************************************************************************
 * * dummy_ril.c - dummy function for ril
 *
 * *(C) Copyright 2019 Asr International Ltd.
 * * All Rights Reserved
 * ******************************************************************************/
#include <stdio.h>
#include <string.h>
#include "ril.h"
#include "ui_log.h"

#ifdef BUILD_IN_PC_SIMULATOR
/* interface for SERVICE DEV begin */

/**
 * RIL_DEV_REQUEST_GET_IMEI
 * param       RIL_DEV_REQUEST_GET_IMEI pImei
 * return  RIL_Errno result
 */
RIL_Errno Ril_DEV_Request_Get_Imei(RIL_SIM_ID simId, RIL_DEV_REQUEST_GET_IMEI *pImei)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_DEV_REQUEST_GET_IMEISV
 * param       RIL_DEV_REQUEST_GET_IMEISV pImeisv
 * return  RIL_Errno result
 */
RIL_Errno Ril_DEV_Request_Get_Imeisv(RIL_SIM_ID simId, RIL_DEV_REQUEST_GET_IMEISV *pImeisv)
{
    return RIL_E_SUCCESS;    
}

/**
 * RIL_DEV_REQUEST_BASEBAND_VERSION
 * param       RIL_DEV_REQUEST_BASEBAND_VERSION pBasebandVer
 * return  RIL_Errno result
 */
RIL_Errno Ril_DEV_Request_Baseband_Version(RIL_DEV_REQUEST_BASEBAND_VERSION *pBasebandVer)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_DEV_REQUEST_OEM_HOOK_RAW
 * param       RIL_DEV_REQUEST_OEM_HOOK_RAW pOemHookRawReq
 *             RIL_DEV_RESPONSE_OEM_HOOK_RAW pOemHookRawRes
 * return  RIL_Errno result
 */
RIL_Errno Ril_DEV_Request_Oem_Hook_Raw(RIL_DEV_REQUEST_OEM_HOOK_RAW *pOemHookRawReq,
    RIL_DEV_RESPONSE_OEM_HOOK_RAW                                   *pOemHookRawRes)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_DEV_REQUEST_OEM_HOOK_STRING
 * param       RIL_DEV_REQUEST_OEM_HOOK_STRING pOemHookStrReq
 *             RIL_DEV_RESPONSE_OEM_HOOK_STRING pOemHookStrRes
 * return  RIL_Errno result
 */
RIL_Errno Ril_DEV_Request_Oem_Hook_String(RIL_DEV_REQUEST_OEM_HOOK_STRING *pOemHookStrReq,
    RIL_DEV_RESPONSE_OEM_HOOK_STRING                                      *pOemHookStrRes)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_DEV_REQUEST_DEVICE_ID
 * param       RIL_DEV_REQUEST_DEVICE_ID pDeviceId
 * return  RIL_Errno result
 */
RIL_Errno Ril_DEV_Request_Device_Id(RIL_DEV_REQUEST_DEVICE_ID *pDeviceId)
{
    return RIL_E_SUCCESS;
}

/* interface for SERVICE DEV end */

/* interface for SERVICE SIM begin */

/**
 * RIL_REQUEST_GET_CP_PHONEBOOK_STATUS(AT+CPBS?)
 * Request CP phonebook status
 * param   RIL_SIM_ID simId: SIM ID
 * return  void
 */
void Ril_SIM_Request_Get_Phonebook_Status(RIL_SIM_ID simId)
{
}

/**
 * RIL_REQUEST_WRITE_PHONEBOOK(AT+CPBW=)
 * Request CP to write new contact into phonebook
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_Contact *p_contact: the contact to be written into phonebook
 * return  void
 */
void Ril_SIM_Request_Write_Phonebook(RIL_SIM_ID SimId, RIL_Contact *p_contact)
{
}

/**
 * RIL_REQUEST_READ_PHONEBOOK(AT+CPBR=)
 * Request CP to read contacts from phonebook
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_ReadPbIndex index: first and end index of contact to read
 * return  void
 */
void Ril_SIM_Request_Read_Phonebook(RIL_SIM_ID simId, RIL_ReadPbIndex index)
{
}


/**
 * RIL_REQUEST_GET_SIM_STATUS(AT+CPIN?)
 * Request status of the SIM interface and the SIM card
 * param   RIL_SIM_ID simId: SIM ID
 * return  void
 */
void Ril_SIM_Request_Get_Sim_Status(RIL_SIM_ID simId)
{
}

/**
 * RIL_REQUEST_QUERY_FACILITY_LOCK
 *
 * Query the status of a facility lock state
 *
 * "data" is const char **
 * ((const char **)data)[0] is the facility string code from TS 27.007 7.4
 *                      (eg "AO" for BAOC, "SC" for SIM lock)
 * ((const char **)data)[1] is the password, or "" if not required
 * ((const char **)data)[2] is the TS 27.007 service class bit vector of
 *                           services to query
 * ((const char **)data)[3] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value.
 *                            This is only applicable in the case of Fixed Dialing Numbers
 *                            (FDN) requests.
 *
 * "response" is an int *
 * ((int *)response) 0 is the TS 27.007 service class bit vector of
 *                           services for which the specified barring facility
 *                           is active. "0" means "disabled for all"
 *
 *
 * return  RIL_Errno: RIL_E_SUCCESS, RIL_E_xxx
 * Valid errors:
 *  SUCCESS
 *  RADIO_NOT_AVAILABLE
 *  SS_MODIFIED_TO_DIAL
 *  SS_MODIFIED_TO_USSD
 *  SS_MODIFIED_TO_SS
 *  INVALID_ARGUMENTS
 *  NO_MEMORY
 *  INTERNAL_ERR
 *  SYSTEM_ERR
 *  MODEM_ERR
 *  FDN_CHECK_FAILURE
 *  NO_RESOURCES
 *  CANCELLED
 *  REQUEST_NOT_SUPPORTED
 *
 * return  void
 */
RIL_Errno Ril_SIM_Request_Query_Facility_Lock(RIL_SIM_ID SimId, const unsigned char **data,
    int *response)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_REQUEST_SET_FACILITY_LOCK
 *
 * Enable/disable one facility lock
 *
 * "data" is const char **
 *
 * ((const char **)data)[0] = facility string code from TS 27.007 7.4
 * (eg "AO" for BAOC)
 * ((const char **)data)[1] = "0" for "unlock" and "1" for "lock"
 * ((const char **)data)[2] = password
 * ((const char **)data)[3] = string representation of decimal TS 27.007
 *                            service class bit vector. Eg, the string
 *                            "1" means "set this facility for voice services"
 * ((const char **)data)[4] = AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value.
 *                            This is only applicable in the case of Fixed Dialing Numbers
 *                            (FDN) requests.
 *
 * "response" is int *
 * ((int *)response)[0] is the number of retries remaining, or -1 if unknown
 *
 * return  RIL_Errno: RIL_E_SUCCESS, RIL_E_xxx
 * Valid errors:
 *  SUCCESS
 *  RADIO_NOT_AVAILABLE
 *  SS_MODIFIED_TO_DIAL
 *  SS_MODIFIED_TO_USSD
 *  SS_MODIFIED_TO_SS
 *  INVALID_ARGUMENTS
 *  INTERNAL_ERR
 *  NO_MEMORY
 *  MODEM_ERR
 *  INVALID_STATE
 *  FDN_CHECK_FAILURE
 *  NO_RESOURCES
 *  CANCELLED
 *  REQUEST_NOT_SUPPORTED
 *
 */
RIL_Errno Ril_SIM_Request_Set_Facility_Lock(RIL_SIM_ID SimId, const char **data, int *response)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_REQUEST_GET_IMSI(AT+CIMI)
 * Request to get the SIM IMSI
 * param   RIL_SIM_ID simId: SIM ID
 * return  void
 */
void Ril_SIM_Request_Get_Imsi(RIL_SIM_ID SimId)
{

}

/**
 * RIL_REQUEST_LOCK_INFO(AT+EPIN)
 * Request to get PIN/PUK lock info
 * param   RIL_SIM_ID SimId: SIM ID
 * return  void
 */
void Ril_SIM_Request_Query_Lock_Info(RIL_SIM_ID SimId)
{
}

/**
 * RIL_REQUEST_ENTER_SIM_PIN(AT+CPIN=)
 * Request to enter SIM PIN
 * param   RIL_SIM_ID simId: SIM ID
 *         char *p_pin: PIN string
 * return  void
 */
void Ril_SIM_Request_Enter_Sim_Pin(RIL_SIM_ID SimId, char *p_pin)
{
}

/**
 * RIL_REQUEST_ENTER_SIM_PUK(ATD**05*)
 * Request to enter SIM PUK and new PIN
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_SIM_REQUEST_ENTER_PUK *p_pukAndPin: PUK and new PIN string
 * return  void
 */
void Ril_SIM_Request_Enter_Sim_Puk(RIL_SIM_ID simId, RIL_SIM_REQUEST_ENTER_PUK *p_pukAndPin)
{
}

/**
 * RIL_REQUEST_ENTER_SIM_PIN2(AT+CPIN=)
 * Request to enter SIM PIN2
 * param   RIL_SIM_ID simId: SIM ID
 *         char *p_pin2: PIN2 string
 * return  void
 */
void Ril_SIM_Request_Enter_Sim_Pin2(RIL_SIM_ID SimId, char *p_pin2)
{
}

/**
 * RIL_REQUEST_ENTER_SIM_PUK2(ATD**052*)
 * Request to enter SIM PUK2 and new PIN2.
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_SIM_REQUEST_ENTER_PUK *p_puk2AndPin2: PUK2 and new PIN2 string
 * return  void
 */
void Ril_SIM_Request_Enter_Sim_Puk2(RIL_SIM_ID simId, RIL_SIM_REQUEST_ENTER_PUK *p_puk2AndPin2)
{
}

/**
 * RIL_REQUEST_CHANGE_SIM_PIN(AT+CPIN= , )
 * Request to enter old SIM PIN and new PIN.
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_SIM_REQUEST_CHANGE_PIN *p_changePin: the old PIN2 and new PIN string
 * return  void
 */
void Ril_SIM_Request_Change_Sim_Pin(RIL_SIM_ID simId, RIL_SIM_REQUEST_CHANGE_PIN *p_changePin)
{
}

/**
 * RIL_REQUEST_CHANGE_SIM_PIN2(AT+CPWD=\"P2\", , )
 * Request to enter old SIM PIN2 and new PIN2.
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_SIM_REQUEST_CHANGE_PIN *p_changePin2: the old PIN2 and new PIN2 string
 * return  void
 */
void Ril_SIM_Request_Change_Sim_Pin2(RIL_SIM_ID simId, RIL_SIM_REQUEST_CHANGE_PIN *p_changePin2)
{
}

/**
 * RIL_REQUEST_SIM_IO(AT+CRLA= / AT+CRSM=)
 * Request SIM I/O operation.
 * This is similar to the TS 27.007 "restricted SIM" operation
 * where it assumes all of the EF selection will be done by the
 * callee.
 * param   RIL_SIM_ID simId: SIM ID
 *         RIL_SIM_IO *p_data: data for SIM IO request
 * return  void
 */
void Ril_SIM_Request_Sim_Io(RIL_SIM_ID simId, RIL_SIM_IO *p_data)
{
}

/**
 * RIL_REQUEST_SIM_OPEN_CHANNEL(AT+CCHO=, AT+CGLA=)
 * Open a new logical channel and select the given application. This command
 * reflects TS 27.007 "open logical channel" operation (+CCHO). This request
 * also specifies the P2 parameter (described in ISO 7816-4).
 * param   RIL_SIM_ID simId: SIM ID
 *         char *p_data: a const RIL_OpenChannelParam
 * return  void
 */
void Ril_SIM_Request_Sim_Open_Channel(RIL_SIM_ID simId, char *p_data)
{
}

/**
 * RIL_REQUEST_SIM_CLOSE_CHANNEL(AT+CCHC=)
 * Close a previously opened logical channel. This command reflects TS 27.007
 * "close logical channel" operation (+CCHC).
 * param   RIL_SIM_ID simId: SIM ID
 *         int sessionId: the session ID of logical the channel to close.
 * return  void
 */
void Ril_SIM_Request_Sim_Close_Channel(RIL_SIM_ID simId, int sessionId)
{
}

/* interface for SERVICE SIM end */

/* interface for SERVICE MM begin */

/*
 * RIL_REQUEST_SIGNAL_STRENGTH(AT+CSQ, AT+CESQ)
 * Request current signal strength and bit error rate
 * param   RIL_SignalStrength *pSignalStrength: returned to upper layer, signal strength
 *         RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Signal_Strength(RIL_SignalStrength *pSignalStrength, RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_VOICE_REGISTRATION_STATE(AT$CREG?)
 * Request current voice registration state
 * param   RIL_RegState *pRegState: returned to upper layer, voice registration state
 *         RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Voice_Registration_state(RIL_RegState *pRegState, RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_OPERATOR(AT+COPS=3,0{}+COPS?{}AT+COPS=3,1{}+COPS?{}AT+COPS=3,2{}+COPS?)
 * Request current operator ONS or EONS
 * param   RIL_RegState *pRegState: returned to upper layer, voice operator information
 *         RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Operator(RIL_OperInfo *pOperInfo, RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_RADIO_POWER(AT+CFUN=1)
 * Power on command for flight mode
 * param(in)   RIL_SIM_ID simId: SIM ID
 * param(in)   RadioOn simId: BOOL true to turn on the radio power, false to turn off the radio power
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Radio_Power(RIL_SIM_ID simId, unsigned char RadioOn)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE(AT+COPS?)
 * Query current network selection mode
 * param   RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Query_Network_Selection_Mode(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC(AT+COPS?)
 * Specify that the network should be selected automatically
 * param   RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_INTERNAL_ERR)
 */
RIL_Errno Ril_MM_Request_Set_Network_Selection_Automatic(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL(AT+COPS=1,2,)
 * Manually select a specified network
 * param   RIL_OperInfo operInfo: parameter of setting network selection manual
 *         RIL_SIM_ID simId: SIM ID
 * return  void
 */
RIL_Errno Ril_MM_Request_Set_Network_Selection_Manual(RIL_OperInfo operInfo, RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_QUERY_AVAILABLE_NETWORKS(AT+COPS=?)
 * Scans for available networks
 * param   RIL_SIM_ID simId: SIM ID
 * return  void
 */
RIL_Errno Ril_MM_Request_Query_Available_Networks(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_RESET_RADIO(AT+CFUN=4, AT+CFUN=1)
 * Reset radio according to CFUN4 and CFUN1
 * param   RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Reset_Radio(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_SCREEN_STATE(AT*POWERIND=0, AT*POWERIND=1)
 * Notify CP that AP will wake or sleep
 * param   RIL_SIM_ID simId: SIM ID
 * return  void
 */
void Ril_MM_Request_Screen_State(void)
{
}

/*
 * RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE(AT*BAND?, )
 * Request to set the preferred network type of searching and registering
 * param   RIL_PreferredNetworkType NetworkType: index of RILNetworkTypeTostarBandNetworkType[]
 *         RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR, RIL_E_MODE_NOT_SUPPORRTED)
 */
RIL_Errno Ril_MM_Request_Set_Preferred_Network_Type(RIL_PreferredNetworkType NetworkType,
    RIL_SIM_ID                                                               simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE(AT*BAND?)
 * Query the preferred network type for searching and registering
 * param   RIL_PreferredNetworkType *pNetworkType: returned to upper layer, network type
 *         RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Get_Preferred_Network_Type(RIL_PreferredNetworkType *pNetworkType,
    RIL_SIM_ID                                                               simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_SET_LOCATION_UPDATES(AT+CREG=2)
 * Enables/Disable network state change notification due to change in LAC and/or CID
 * param   RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Set_Location_Updates(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_SHUTDOWN(AT+CFUN=0)
 * Shurdown command
 * param   RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Shutdown(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/*
 * RIL_REQUEST_CANCEL_PLMN_SEARCH(AT+CPLMNS)
 * Notify modem to cancell plmn search
 * param   RIL_SIM_ID simId: SIM ID
 * return  RIL_Errno(RIL_E_SUCCESS, RIL_E_MODEM_ERR)
 */
RIL_Errno Ril_MM_Request_Cancel_Plmn_Search(RIL_SIM_ID simId)
{
    return RIL_E_SUCCESS;
}

/* interface for SERVICE MM end */

/* interface for SERVICE MSG begin */

/**
 * RIL_MSG_REQUEST_SEND_SMS
 * param       RIL_MSG_REQUEST_SEND_SMS pSendSmsReq
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Send_Sms(RIL_MSG_REQUEST_SEND_SMS *pSendSmsReq)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_WRITE_SMS_TO_SIM
 * param       RIL_MSG_REQUEST_WRITE_SMS_TO_SIM pWriteSmsReq
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Write_Sms_to_Sim(RIL_MSG_REQUEST_WRITE_SMS_TO_SIM *pWriteSmsReq)
{
    return RIL_E_SUCCESS;
}

/**
 * Ril_MSG_Request_Read_Sms_Info_From_Sim
 * param       RIL_MSG_READ_SMS_TYPE eReadSmsType
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Read_Sms_Info_From_Sim(RIL_MSG_READ_SMS_TYPE eReadSmsType)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_READ_SINGLE_SMS_FROM_SIM
 * param       RIL_MSG_REQUEST_READ_SINGLE_SMS_FROM_SIM pReadSingleSms
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Read_Single_Sms_From_Sim(
    RIL_MSG_REQUEST_READ_SINGLE_SMS_FROM_SIM *pReadSingleSms)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_DELETE_SMS_ON_SIM
 * param       RIL_MSG_REQUEST_DELETE_SMS_ON_SIM pDeleteSms
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Delete_Sms_On_Sim(RIL_MSG_REQUEST_DELETE_SMS_ON_SIM *pDeleteSms)
{
    return RIL_E_SUCCESS;
}

/**
 * Ril_MSG_Request_Get_Broadcast_Sms_Cfg
 * param       RIL_SIM_ID eSimId
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Get_Broadcast_Sms_Cfg(RIL_SIM_ID eSimId)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_SET_BROADCAST_SMS_CFG
 * param       RIL_MSG_REQUEST_SET_BROADCAST_SMS_CFG pSetBrdcastSmsCfg
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Set_Broadcast_Sms_Cfg(
    RIL_MSG_REQUEST_SET_BROADCAST_SMS_CFG *pSetBrdcastSmsCfg)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_SMS_BROADCAST_ACT
 * param       RIL_MSG_REQUEST_SMS_BROADCAST_ACT pSmsBrdcastAct
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Sms_Broadcast_Act(RIL_MSG_REQUEST_SMS_BROADCAST_ACT *pSmsBrdcastAct)
{
    return RIL_E_SUCCESS;
}

/**
 * Ril_MSG_Request_Get_Smsc_Addr
 * param       RIL_SIM_ID eSimId
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Get_Smsc_Addr(RIL_SIM_ID eSimId)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_SET_SMSC_ADDRESS
 * param       RIL_MSG_REQUEST_SET_SMSC_ADDRESS pSetSmscAddr
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Set_Smsc_Addr(RIL_MSG_REQUEST_SET_SMSC_ADDRESS *pSetSmscAddr)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_MSG_REQUEST_ACK_INCOME_SMS_WITH_PDU
 * param       RIL_MSG_REQUEST_ACK_INCOME_SMS_WITH_PDU pAckWithPdu
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Ack_Incoming_Sms_With_Pdu(
    RIL_MSG_REQUEST_ACK_INCOME_SMS_WITH_PDU *pAckWithPdu)
{
    return RIL_E_SUCCESS;
}

/**
 * RIL_DEV_REQUEST_SMS_ACKNOWLEDGE
 * param       RIL_DEV_SMS_ACKNOWLEDGE eSmsAck: Acknowledge
 * return  RIL_Errno result
 */
RIL_Errno Ril_MSG_Request_Sms_Acknowledge(RIL_DEV_REQUEST_SMS_ACKNOWLEDGE *pSmsAck)
{
    return RIL_E_SUCCESS;
}

/* interface for SERVICE MSG end */

/* interface for SERVICE CC begin */

/**
 * Requests current call list ( AT+CLCC)
 * param (in) sid:  RIL_SIM_ID
 * param (out) calls:  RIL_CC_REQUEST_GET_CURRENT_CALLS *   //caller alloc & free
 *                      typedef struct {
 *                      RIL_Call *calls{}                    //caller alloc & free
 *                      int      count{}
 *                      } RIL_CC_REQUEST_GET_CURRENT_CALLS{}
 *
 *                     typedef struct {
 *                         RIL_CallState state{}
 *                         int           index{}
 *                         int           toa{}
 *                         char          isMpty{}
 *                         char          isMT{}
 *                         char          als{}
 *                         char          isVoice{}
 *                         char          isVoicePrivacy{}
 *                         char          *number{}           //ril alloc, caller free
 *                         int           numberPresentation{}
 *                         char          *name{}             //ril alloc, caller free
 *                         int           namePresentation{}
 *                         RIL_UUS_Info  *uusInfo{}          //ril alloc, caller free
 *                     } RIL_Call{}
 *
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Get_Current_Calls(RIL_SIM_ID sid, RIL_CC_REQUEST_GET_CURRENT_CALLS *calls)
{
    return RIL_E_SUCCESS;
}

/**
 * Initiate voice call ( ATD<dial string>{} or AT*DIALE=<dial string>,<service Type>)
 * param (in) sid:  RIL_SIM_ID
 * param (in) dial:  RIL_Dial *
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Dial(RIL_SIM_ID sid, RIL_Dial *dial)
{
    return RIL_E_SUCCESS;
}

/**
 * Hang up a specific line (like AT+CHLD=1x)
 * param (in) sid:  RIL_SIM_ID
 * param (in) index:   Connection index (value of 'x' in CHLD above)
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Hangup(RIL_SIM_ID sid, int index)
{
    return RIL_E_SUCCESS;
}

/**
 * Hang up waiting or held (like AT+CHLD=0)
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Hangup_Waiting_Or_Background(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Hang up active, and resume waiting or held (like AT+CHLD=1)
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Hangup_Foreground_Resume_Background(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/*
 * Switch waiting or holding call and active call (like AT+CHLD=2)
 *
 * State transitions should be is follows:
 *
 * If call 1 is waiting and call 2 is active, then if this re
 *
 *   BEFORE                               AFTER
 * Call 1   Call 2                 Call 1       Call 2
 * ACTIVE   HOLDING                HOLDING     ACTIVE
 * ACTIVE   WAITING                HOLDING     ACTIVE
 * HOLDING  WAITING                HOLDING     ACTIVE
 * ACTIVE   IDLE                   HOLDING     IDLE
 * IDLE     IDLE                   IDLE        IDLE
 *
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Switch_Waiting_Or_Holding_And_Active(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Conference holding and active (like AT+CHLD=3)
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Conference(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Separate a party from a multiparty call placing the multiparty call
 * (less the specified party) on hold and leaving the specified party
 * as the only other member of the current (active) call
 *
 * Like AT+CHLD=2x
 *
 * See TS 22.084 1.3.8.2 (iii)
 * TS 22.030 6.5.5 "Entering "2X followed by send"
 * TS 27.007 "AT+CHLD=2x"
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) index:   Connection index (value of 'x' in CHLD above)
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Separate_Connection(RIL_SIM_ID sid, int index)
{
    return RIL_E_SUCCESS;
}

/**
 * Connects the two calls and disconnects the subscriber from both calls (ECT). (AT+CHLD=4)
 *
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Explicit_Call_Transfer(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Send UDUB (user determined user busy) to ringing or
 * waiting call answer  (AT+CHLD=0)
 *
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Udub(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Answer incoming call (ATA)
 *
 * Will not be called for WAITING calls.
 * RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE will be used in this case instead
 *
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Answer(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Send a DTMF tone (AT+VTS=<DTMF>)
 *
 * If the implementation is currently playing a tone requested via
 * RIL_REQUEST_DTMF_START, that tone should be cancelled and the new tone
 * should be played instead
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) dtmf:  RIL_CC_REQUEST_DTMF *
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Dtmf(RIL_SIM_ID sid, RIL_CC_REQUEST_DTMF *dtmf)
{
    return RIL_E_SUCCESS;
}

/**
 * Start playing a DTMF tone. Continue playing DTMF tone until
 * RIL_REQUEST_DTMF_STOP is received (AT+VTS=<DTMF>)
 *
 * If a RIL_REQUEST_DTMF_START is received while a tone is currently playing,
 * it should cancel the previous tone and play the new one.
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) dtmf: a single character with one of 12 values: 0-9,*,#
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Dtmf_Start(RIL_SIM_ID sid, char dtmf)
{
    return RIL_E_SUCCESS;
}

/**
 * Stop playing a currently playing DTMF tone. (AT)
 *
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Dtmf_stop(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Turn on or off uplink (microphone) mute. ("AT+CMUT=<n>)
 *
 * Will only be sent while voice call is active.
 * Will always be reset to "disable mute" when a new voice call is initiated
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) mute:   1 for "enable mute" and 0 for "disable mute"
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Set_Mute(RIL_SIM_ID sid, int mute)
{
    return RIL_E_SUCCESS;
}

/**
 * Queries the current state of the uplink mute setting (AT+CMUT?)
 *
 * param (in) sid:  RIL_SIM_ID
 * param (out) mute:   1 for "mute enabled" and 0 for "mute disabled"
 * return  RIL_Errno
 */
RIL_Errno Ril_CC_Request_Get_Mute(RIL_SIM_ID sid, int *mute)
{
    return RIL_E_SUCCESS;
}


/* interface for SERVICE CC end */

/* interface for SERVICE SS begin */

/*
 * Send a USSD message (AT+CUSD=1,str,15)
 *
 * If a USSD session already exists, the message should be sent in the
 * context of that session. Otherwise, a new session should be created.
 *
 * The network reply should be reported via RIL_UNSOL_ON_USSD
 *
 * Only one USSD session may exist at a time, and the session is assumed
 * to exist until:
 *   a) The android system invokes RIL_REQUEST_CANCEL_USSD
 *   b) The implementation sends a RIL_UNSOL_ON_USSD with a type code
 *      of "0" (USSD-Notify/no further action) or "2" (session terminated)
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) str:    a char * containing the USSD request in UTF-8 format
 * return  RIL_Errno
 */
RIL_Errno Ril_SS_Request_Send_Ussd(RIL_SIM_ID sid, char *str)
{
    return RIL_E_SUCCESS;
}

/**
 * Cancel the current USSD session if one exists (AT+CUSD=2)
 *
 * param (in) sid:  RIL_SIM_ID
 * return  RIL_Errno
 */
RIL_Errno Ril_SS_Request_Cancel_Ussd(RIL_SIM_ID sid)
{
    return RIL_E_SUCCESS;
}

/**
 * Get call forward status
 * (AT+CCFC=<reason>,2,,,<class>)
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) forward:  RIL_CallForwardInfo *
 *
 * param (out) result:  RIL_SS_REQUEST_QUERY_CALL_FORWARD_STATUS *
 *
 * For example, if data is forwarded to +18005551212 and voice is forwarded
 * to +18005559999, then two separate RIL_CallForwardInfo's should be returned
 *
 * If, however, both data and voice are forwarded to +18005551212, then
 * a single RIL_CallForwardInfo can be returned with the service class
 * set to "data + voice = 3")
 *
 * return  RIL_Errno
 */
RIL_Errno Ril_SS_Request_Query_Call_Forward_Status(RIL_SIM_ID sid, RIL_CallForwardInfo *forward,
    RIL_SS_REQUEST_QUERY_CALL_FORWARD_STATUS *result)
{
    return RIL_E_SUCCESS;
}

/**
 * Configure call forward rule.
 * (AT+CCFC=<reason>,<mode>[,<number>[,<type>[,<class>[,<subaddr>[,<satype>[,<time>]]]]]])
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) forward:     RIL_CallForwardInfo *
 * return  RIL_Errno
 */
RIL_Errno Ril_SS_Request_Set_Call_Forward(RIL_SIM_ID sid, RIL_CallForwardInfo *forward)
{
    return RIL_E_SUCCESS;
}

/**
 * Query current call waiting state (AT+CCWA=1,2,class)
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) class:  the TS 27.007 service class to query.
 * param (out) result:  RIL_SS_REQUEST_QUERY_CALL_WAITING *
 *
 * If status = 1, then classx
 * must follow, with the TS 27.007 service class bit vector of services
 * for which call waiting is enabled.
 *
 * For example, if status is 1 and
 * classx is 3, then call waiting is enabled for data
 * and voice and disabled for everything else
 *
 * return  RIL_Errno
 */
RIL_Errno Ril_SS_Request_Query_Call_Waiting(RIL_SIM_ID sid, int class,
    RIL_SS_REQUEST_QUERY_CALL_WAITING *result)
{
    return RIL_E_SUCCESS;
}

/**
 * Configure current call waiting state (AT+CCWA=1,<mode>,<class>)
 *
 * param (in) sid:  RIL_SIM_ID
 * param (in) wait:   RIL_SS_REQUEST_SET_CALL_WAITING *
 *
 * return  RIL_Errno
 */
RIL_Errno Ril_SS_Request_Set_Call_Waiting(RIL_SIM_ID sid, RIL_SS_REQUEST_SET_CALL_WAITING *wait)
{
    return RIL_E_SUCCESS;
    
}

#endif // BUILD_IN_PC_SIMULATOR
